import _ from 'lodash'
import specsgoods from "@/components/guige/guige";
export default {
  data() {
    return {

      form: {
        token: '', //七牛token
        Url: '', //获取上传路径
        domain: '' //上传路径 二级
      },
      quanzhongValue: 0,
      radio: '2',
      VIPmoney: "",
      productStatus: '1',
      productSort: '1',
      productTj: '2',
      fileList: [],
      params: {
        token: '',
        key: ''
      },
      // 被激活的页签的名称
      activeName: '0',
      // 所有商品的分类列表
      catelist: [],
      // 级联选择框中，数据的对应关系
      cascaderProps: {
        label: 'cat_name',
        value: 'cat_id',
        children: 'children'
      },
      // 添加商品的表单对象
      addForm: {
        goods_name: '', // 商品名称
        goods_price: '', // 商品价格
        goods_weight: '', // 商品重量
        goods_number: '', // 商品数量
        goods_cy_price: '',//商品cy价格
        goods_cat: [], // 商品所属的分类
        goods_introduce: '', // 商品的描述
        picDetails: [],//商品详情图片
        pics: [], // 商品的图片
        attrs: [], // 商品的属性数组,
        picture: '',
        type: '',//商品类别
        vipMoney: '',
        specification:[],
        remark:''
      },
      productTypeList: [],
      title: '请选择',
      // 添加商品的表单验证对象
      addFormRules: {
        goods_name: [{ required: true, message: '请输入商品名称', trigger: 'blur' }],
        goods_price: [{ required: true, message: '请输入商品价格', trigger: 'blur' }],
        goods_weight: [{ required: true, message: '请输入商品重量', trigger: 'blur' }],
        goods_number: [{ required: true, message: '请输入商品数量', trigger: 'blur' }],
        goods_cat: [{ required: true, message: '请选择商品分类', trigger: 'blur' }]
      },
      // 所有的动态参数
      manyParams: [],
      // 所有的静态属性
      onlyParams: [],
      // 上传图片时候，要传递的请求头
      uploadHeader: {
        // 需要手动指定一个 Authorization
        Authorization: ''
      },
      // 控制图片预览窗口的显示与隐藏
      previewDialogVisible: false,
      // 图片预览的地址
      previewURL: '',


      editType: true, //判定商品属性标签是否可编辑
      attr_names: [
        // 为了方便理解用 保留
        // {label: '成本', prop: 'cost_price'},
        // {label: '售价', prop: 'price'},
        // {label: '库存', prop: 'quantity'}, 
        // {label: '货号', prop: 'no'},
      ],
      tableData: [
        {
          cost_price: '', //成本价
          price: ' ',//售价
          quantity: '',//库存
          no: '',//货号
          img: '',//图片
          editable: true //判定SKU是否可编辑
        }
      ],
      dialogVisible: false,
      selectServiceList:[],
      dialogImageUrl:'',
      dialogVisiblePrient: false,
      guigeData:{},
      fileList2: [],
      fileList3: [],

      selectType:[],
      options:[]
    }
  },
  components:{
    specsgoods
  },
  async created() {
    let data = this.$route.query.params;
    console.log(data);
    this.queryId = data.id;
    
    this.getProductDetails();
    console.log(99999);
    this.addForm.id = data.id;
    this.getQnToken();
    
    
    
    //this.getCateList()
    // 从 sessionStorage 中获取 token 字符串
    // 把 token 字符串，交给 uploadHeader.Authorization 即可
    const tokenStr = sessionStorage.getItem('token')
    this.uploadHeader.Authorization = tokenStr
  },
  methods: {
    getProductDetails() {
      console.log(132465465); 
      let params = { 
        queryId: this.queryId
      } 
      this.$http.post('/shop/productInfo', params).then(res=>{
        console.log(res.data);
        if(res.data.status==1){
          this.addForm.goods_name=res.data.data.name;
          this.addForm.picture=res.data.data.image;
          this.addForm.specification=res.data.data.skuList;
          this.addForm.type=res.data.data.type;
          this.getProductType();
          
          
          let serveList=[];
          JSON.parse(res.data.data.goodService).forEach(item=>{
            if(item=='无忧退货'){
              serveList.push(1);
            }else if(item=="保证正品"){
              serveList.push(2);
            }else if(item=="免费包邮"){
              serveList.push(3);
            }
          })
          this.selectServiceList=serveList;
          let detailsList=[];
          let picDataOne=[];
          JSON.parse(res.data.data.detailPhoto).forEach((item,i)=>{
            let obj={pic:item};
            let obj1 = {
              name: 'image' + i,
              url: item
            }
            picDataOne.push(obj1);
            detailsList.push(obj);
          })
          this.fileList2=picDataOne;
          this.addForm.picDetails=detailsList;
          let picList=[];
          let dataListTwo=[];
          JSON.parse(res.data.data.images).forEach((item,i)=>{
            let obj={pic:item};
            let obj1 = {
              name: 'image' + i,
              url: item
            }
            dataListTwo.push(obj1);
            picList.push(obj);
          })
          this.addForm.pics=picList;
          this.fileList3=dataListTwo;
          let newDataList=[];
          res.data.data.skuList.forEach((item,index)=>{
            // let obj={
            //   id:'',
            //   image:item.rule_image,
            //   description:JSON.stringify(item.describe),
            //   inPrice:item.rule_price,
            //   integral:item.sfIntegral,
            //   linePrice:item.huaxianjia,
            //   price:item.rule_cost,
            //   releaseNum:item.sfNum,
            //   stock:item.rule_unit,
            //   postMoney:item.youfei
            // }
            let obj={
              rule_id:item.id,
              rule_cost:item.price,
              rule_unit:item.stock,
              rule_price:item.inPrice,
              rule_image:item.image,
              rule_name:'',
              describe:JSON.parse(item.description),
              sfIntegral:item.integral,
              huaxianjia:item.linePrice,
              sfNum:item.releaseNum,
              youfei:item.postMoney
            }
            JSON.parse(item.description).forEach(twoItem=>{
              obj.rule_name+=twoItem.title+':'+twoItem.content+'/';
            })
            obj.rule_name=obj.rule_name.slice(0,-1);
            newDataList.push(obj);
          })
          console.log(newDataList);
          this.guigeData.dataThree=newDataList;
          this.guigeData.dataOne=JSON.parse(res.data.data.remark).dataOne;
          this.guigeData.dataTwo=JSON.parse(res.data.data.remark).dataTwo;
          console.log(this.addForm);
        }else{
          return this.$message.error(res.data.message);
        }
      }) 
      
      // this.addForm.goods_introduce = res.data.detail.specification;
      // this.addForm.picDetails = JSON.parse(res.data.detail.details);
      // let picOneData = [];

      // this.addForm.picDetails.forEach((item, i) => {
      //   let obj = {
      //     name: 'image' + i,
      //     url: item
      //   }
      //   picOneData.push(obj);
      // })

      // this.guigeData=res.data.data;

      // // let dataList = [];

      // let newDataList=[];
      // res.data.skuList.forEach((item,index)=>{
      //   let obj={
      //     rule_id:item.id,
      //     rule_cost:item.money,
      //     rule_unit:item.stock,
      //     rule_price:item.inMoney,
      //     rule_image:item.img,
      //     rule_name:'',
      //     fileList:[{name:index+'.jpg',url:item.img}]
      //   }
      //   JSON.parse(item.description).forEach(twoItem=>{
      //     obj.rule_name+=twoItem.title+':'+twoItem.content+'/';
      //   })
      //   obj.rule_name=obj.rule_name.slice(0,-1);
      //   newDataList.push(obj);
      // })
      // console.log(newDataList);
      // this.guigeData.dataThree=newDataList;

      

      // JSON.parse(res.data.skuList[0].description).forEach(twoItem => {
      //   let obj = { rule_id: "", rule_name: twoItem.title}
      //   dataList.push(obj);

      // })
      // console.log(dataList);
      // this.editRuledata=dataList;
      
      // let dataListTwo=[];
      // res.data.skuList.forEach(oneItem=>{ 
      //   let ss = {
      //     k_rule_id: "",
      //     k_rule_name: '',
      //     k_rule: false,
      //     k_provaluse: "", //属性
      //     k_moreruledata: []
      //   };
      //   let dataListThree=[];
      //   JSON.parse(oneItem.description).forEach(twoItem => {
      //     let dd = { rule_id: "", rule_name: item.provaluse };
      //   })
      //   dataListTwo.push(obj);
      // })

      // let ss = {
      //   k_rule_id: item.rule_id,
      //   k_rule_name: item.rule_name,
      //   k_rule: false,
      //   k_provaluse: "", //属性
      //   k_moreruledata: []
      // };

      //this.$refs.ch.ruledata=dataList;



      // this.fileList3 = picOneData;
      // console.log(this.fileList3);
    },
    selelctService(e){
      console.log(e);
      this.selectServiceList=e;
    },
    delbeforeUploadNew(file){
      this.params.key =new Date().getTime();// file.name
    },
    //新商城轮播图方法
    deluploadSuccessNew(result) {
      // console.log(result)
      // 只要图片上传成功，都要 怼出这么一个对象：
      //  { pic: '图片的地址' }
      // 把怼出的对象，push 到this.addForm.pics 中
      let picUrl = this.form.domain + result.key;
      const obj = { pic: picUrl }
      console.log(obj, '上传图片的地址')
      this.addForm.picDetails.push(obj)
      // console.log(this.addForm)
    },

    delhandleRemoveNew(file, fileList) {
      const index = this.addForm.picDetails.findIndex(x => x === file.url)
      // 根据索引。把 表单中记录的图片信息对象，删除
      this.addForm.picDetails.splice(index, 1)
    },


    handleAvatarSuccess(res, file) {
      console.log(file.raw);
      this.addForm.picture = this.form.domain+ file.response.key;
    },
    beforeAvatarUpload(file) {
      console.log(file)
      this.params.key =new Date().getTime();// file.name
      // const isJPG = file.type === 'image/jpeg';
      // const isLt2M = file.size / 1024 / 1024 < 2;

      // if (!isJPG) {
      //   this.$message.error('上传头像图片只能是 JPG 格式!');
      // }
      // if (!isLt2M) {
      //   this.$message.error('上传头像图片大小不能超过 2MB!');
      // }
      // return isJPG && isLt2M;
    },
    beforeUploadNew(file){
      this.params.key =new Date().getTime();// file.name
    },
    //新商城轮播图方法
    uploadSuccessNew(result) {
      // console.log(result)
      // 只要图片上传成功，都要 怼出这么一个对象：
      //  { pic: '图片的地址' }
      // 把怼出的对象，push 到this.addForm.pics 中
      let picUrl = this.form.domain + result.key;
      const obj = { pic: picUrl }
      console.log(obj, '上传图片的地址')
      this.addForm.pics.push(obj)
      // console.log(this.addForm)
    },

    handleRemoveNew(file, fileList) {
      const index = this.addForm.pics.findIndex(x => x === file.url)
      // 根据索引。把 表单中记录的图片信息对象，删除
      this.addForm.pics.splice(index, 1)
      console.log(this.addForm.pics);
    },
    handlePictureCardPreviewNew(file) {
      this.dialogImageUrl = file.url;
      this.dialogVisiblePrient = true;
    },
    //添加规格
    confirmGuiGe(){
      
      this.dialogVisible=true;
      setTimeout(()=>{
        console.log(this.guigeData);
        this.$refs.ch.ruledata=this.guigeData.dataOne;
        this.$refs.ch.k_ruledata=this.guigeData.dataTwo;
        this.$refs.ch.autoruledata=this.guigeData.dataThree;
        this.$refs.ch.autodata_rule=true;
        //console.log(this.$refs.ch.ruledata);
      },300)
     
    },
    confirmGuiGeData(){
      console.log(this.$refs.ch.autoruledata);
      if(this.$refs.ch.autoruledata.length==0){
        this.$message({
          message: '请完善商品规格信息',
          type: 'warning'
        });
        return;
      }
      let listData=this.$refs.ch.autoruledata;
      for(let i=0;i<listData.length;i++){
        if(!listData[i].rule_cost){
          this.$message({
            message: '请完善商品规格售价信息',
            type: 'warning'
          });
          return;
        }
        console.log(123);
        if(!listData[i].rule_unit){
          this.$message({
            message: '请完善商品规格库存信息',
            type: 'warning'
          });
          return;
        }
        console.log(456);
        if(!listData[i].rule_price){
          this.$message({
            message: '请完善商品规格成本价信息',
            type: 'warning'
          });
          return;
        }
        if(!listData[i].huaxianjia){
          this.$message({
            message: '请完善商品划线价信息',
            type: 'warning'
          });
          return;
        }
        if(!listData[i].sfIntegral){
          this.$message({
            message: '请完善商品释放积分信息',
            type: 'warning'
          });
          return;
        }
        if(!listData[i].sfNum){
          this.$message({
            message: '请完善商品释放数量信息',
            type: 'warning'
          });
          return;
        }
        
        // if(!listData[i].youfei){
        //   this.$message({
        //     message: '请完善商品邮费信息',
        //     type: 'warning'
        //   });
        //   return;
        // }

        if(!listData[i].rule_image){
          this.$message({
            message: '请完善商品规格图片信息',
            type: 'warning'
          });
          return;
        }
      }
 
      
      let obj={
        dataOne:this.$refs.ch.ruledata,
        dataTwo:this.$refs.ch.k_ruledata
      }
      let list=[];
      listData.forEach(item=>{
        let obj={
          id:item.rule_id,
          image:item.rule_image,
          description:JSON.stringify(item.describe),
          
          inPrice:item.rule_price,
          integral:item.sfIntegral,
          linePrice:item.huaxianjia,
          price:item.rule_cost,
          releaseNum:item.sfNum,
          stock:item.rule_unit,
          postMoney:item.youfei
        }
        list.push(obj);
      })
      this.addForm.specification=list;
      this.addForm.remark=JSON.stringify(obj);
      this.dialogVisible=false;
    },
    // 增加商品属性
    addNature() {
      let len = this.attr_names.length;
      //新增以 attr_ 开关，也可以自行定义
      this.attr_names.push({ label: '商品属性', prop: `attr_${len}` })
    },
    // 增加商品SKU
    addSku() {
      let data = this.tableData[0]
      let keys = []
      for (var key in data) {
        keys.push(key);
      }
      let obj = {}
      for (let i = 0; i < keys.length; i++) {
        if (keys[i] === 'editable') {
          obj[keys[i]] = true
        } else {
          obj[keys[i]] = ''
        }
      }
      this.tableData.push(obj);
    },
    //删除一排   tableData ARR
    deleteRow(index, rows) {
      rows.splice(index, 1);
    },
    //删除SKU列 每次删除最后一列数据
    delColumn(index) {
      let len = this.attr_names.length - 1;
      let str = this.attr_names[len].prop;
      this.tableData.map((item) => {
        delete item[str];
      })
      this.attr_names.pop()
    },
    // 调试代码信息用
    logData() {
      console.log('this.attr_names', this.attr_names);
      console.log('this.tableData', this.tableData);
    },


    handleChange(){
      console.log(this.selectType);
      if(this.selectType.length==0){
        this.addForm.type="";
      }else{
        this.addForm.type=this.selectType[this.selectType.length-1];
      }
    },
    getProductType() {
      this.$http.post("/shop/productTypeC", {}).then((res) => {
        // console.log(res)
        if (res.data.status == 1) {
          
          let dataList=[];
          res.data.data.forEach(oneItem=>{
            
            let obj1={
              value:oneItem.id,
              label:oneItem.name,
              children:[]
            }
            oneItem.children.forEach(twoItem=>{
              
              let obj2={
                value:twoItem.id,
                label:twoItem.name
              }
              obj1.children.push(obj2);
            })
            dataList.push(obj1);
          })
          console.log(dataList);
          this.options=dataList;
          this.options.forEach(oneItem=>{
            oneItem.children.forEach(twoItem=>{
              
              if(twoItem.value==this.addForm.type){
                this.selectType=[oneItem.value,twoItem.value];
              }
            })
          })
        }
      });
    },
    handleCommand(command) {
      console.log(this.productTypeList[command]);
      this.title = this.productTypeList[command].name;
      this.addForm.type = this.productTypeList[command].id;
    },
    test() {
      console.log(this.addForm.goods_introduce);
    },
    async getQnToken() {
      const { data: res } = await this.$http.post('/userFile/qiNiuUpload', {})
      console.log(res.data.token);
      this.form.token = res.data.token;
      this.params.token = res.data.token;
      this.form.domain = res.data.domain;
      this.form.Url = res.data.upload_url;
    },
    // 获取商品分类列表
    async getCateList() {
      const { data: res } = await this.$http.get('categories', { params: { type: 3 } })
      console.log(res);
      if (res.meta.status !== 200) return this.$message.error('获取商品分类失败！')
      this.catelist = res.data
    },
    // 每当选中的分类变化，都会触发 这个事件的处理函数
    handleCateChanged() {
      // console.log(this.addForm.goods_cat)
      if (this.addForm.goods_cat.length < 3) {
        this.addForm.goods_cat = []
      }
    },
    dTbeforeUpload(file) {
      console.log(file);
      this.params.key =new Date().getTime();// file.name
      const isJPG = file.type === "image/jpeg" || file.type === "image/png";
      const isLt10M = file.size / 1024 / 1024 < 10;

      if (!isJPG) {
        this.$message.error('上传头像图片只能是 JPG/PNG 格式!');
      }
    },
    beforeUpload(file) {
      console.log(file);
      this.params.key =new Date().getTime();// file.name
      const isJPG = file.type === "image/jpeg" || file.type === "image/png";
      const isLt10M = file.size / 1024 / 1024 < 10;

      if (!isJPG) {
        this.$message.error('上传头像图片只能是 JPG/PNG 格式!');
      }
    },
    beforeUploadDetails(file) {
      console.log(file);
      this.params.key =new Date().getTime();// file.name
      const isJPG = file.type === "image/jpeg" || file.type === "image/png";
      const isLt10M = file.size / 1024 / 1024 < 10;

      if (!isJPG) {
        this.$message.error('上传头像图片只能是 JPG/PNG 格式!');
      }
    },
    // 在离开当前 tab 页签之前，会触发这个方法
    beforeTabLeave() {
      // 在进入下一个页签之前，要确保，用户已经选择了商品分类
      // if (this.addForm.goods_cat.length !== 3) {
      //   this.$message.error('请选择商品分类！')
      //   return false
      // }
    },
    //单图预览
    dThandlePreview(result) {
      console.log(result)
      this.previewURL = result.url
      console.log(this.previewURL);
      this.previewDialogVisible = true
    },
    // 每当要预览图片的时候，会触发这个函数
    handlePreview(result) {

      console.log(result)
      this.previewURL = result.url
      console.log(this.previewURL);
      this.previewDialogVisible = true
    },
    // 每当要预览图片的时候，会触发这个函数
    handlePreviewDetails(result) {

      console.log(result)
      this.previewURL = result.url
      console.log(this.previewURL);
      this.previewDialogVisible = true
    },
    // 每当要删除对应的图片，都会触发这个函数
    // 每当要删除对应的图片，都会触发这个函数
    handleRemove(result) {
      // 根据要删除的图片的地址，找到 图片在 this.addForm.pics 数组中，
      // 所对应的 索引
      const index = this.addForm.pics.findIndex(x => x === result.url)
      // 根据索引。把 表单中记录的图片信息对象，删除
      this.addForm.pics.splice(index, 1)
      // console.log(this.addForm)
    },
    // 每当要删除对应的图片，都会触发这个函数
    dThandleRemove(result) {
      // 根据要删除的图片的地址，找到 图片在 this.addForm.pics 数组中，
      // 所对应的 索引
      //const index = this.addForm.pics.findIndex(x => x.pic === result.response.data.tmp_path)
      // 根据索引。把 表单中记录的图片信息对象，删除
      this.addForm.picture = "";
      // console.log(this.addForm)
    },
    // 每当要删除对应的图片，都会触发这个函数
    handleRemoveDetails(result) {
      console.log(this.addForm.picDetails)
      console.log(result);
      // 根据要删除的图片的地址，找到 图片在 this.addForm.pics 数组中，
      // 所对应的 索引
      const index = this.addForm.picDetails.findIndex(x => x === result.url)
      // 根据索引。把 表单中记录的图片信息对象，删除
      this.addForm.picDetails.splice(index, 1)

      // console.log(this.addForm)
    },
    // 每当图片上传成功，都会触发这个函数
    uploadSuccess(result) {
      // console.log(result)
      // 只要图片上传成功，都要 怼出这么一个对象：
      //  { pic: '图片的地址' }
      // 把怼出的对象，push 到this.addForm.pics 中
      let picUrl = this.form.domain + result.key;
      const obj = { pic: picUrl }
      console.log(obj, '上传图片的地址')
      this.addForm.pics.push(obj)
      // console.log(this.addForm)
    },
    // 每当图片上传成功，都会触发这个函数
    uploadSuccessDetails(result) {
      // console.log(result)
      // 只要图片上传成功，都要 怼出这么一个对象：
      //  { pic: '图片的地址' }
      // 把怼出的对象，push 到this.addForm.pics 中
      let picUrl = this.form.domain + result.key;
      const obj = { pic: picUrl }
      console.log(obj, '上传图片的地址')
      this.addForm.picDetails.push(obj)
      // console.log(this.addForm)
    },
    dTuploadSuccess(result) {
      // console.log(result)
      // 只要图片上传成功，都要 怼出这么一个对象：
      //  { pic: '图片的地址' }
      // 把怼出的对象，push 到this.addForm.pics 中
      let picUrl = this.form.domain + result.key;
      this.addForm.picture = picUrl;
      // console.log(this.addForm)
    },
    // 点击按钮，添加商品
    async addGoods() {
      let params = {
        name: '',//商品名称
        type:'',//类型
        remark:'',
        image:'',//主图
        images:'',//轮播图
        detailPhoto:'',//详情图
        skuList:[],
        goodService:'',
        id:this.queryId
      }

      // goods_name: '', // 商品名称
      //   goods_price: '', // 商品价格
      //   goods_weight: '', // 商品重量
      //   goods_number: '', // 商品数量
      //   goods_cy_price:'',//商品cy价格
      //   goods_cat: [], // 商品所属的分类
      //   goods_introduce: '', // 商品的描述
      //   picDetails:[],//商品详情图片
      //   pics: [], // 商品的图片
      //   attrs: [], // 商品的属性数组,
      //   picture:''
      //差轮播图 
      params.name = this.addForm.goods_name;//
      params.image = this.addForm.picture;//
      params.remark = this.addForm.remark;//
      params.skuList=this.addForm.specification;
      let picList = [];
      this.addForm.picDetails.forEach(item => {
        picList.push(item.pic);
      })
      console.log(picList);
      params.detailPhoto = JSON.stringify(picList);//
     
      let picDetailList = [];
      this.addForm.pics.forEach(item => {
        picDetailList.push(item.pic);
      })

      params.images = JSON.stringify(picDetailList);
      params.type = this.addForm.type;
      if (!this.addForm.goods_name) {
        this.$message.error('请输入商品名称！')
        return;
      }
      if (!this.addForm) {
        this.$message.error('请选择商品分类！')
        return;
      }
      if(this.selectServiceList.length==0){
        this.$message.error('请选择服务保障！')
        return;
      }
      if (!this.addForm.picture) {
        this.$message.error('请上传商品主图！')
        return;
      }
      if (this.addForm.pics.length == 0) {
        this.$message.error('请上传商品轮播图！')
        return;
      }
      if (this.addForm.picDetails.length == 0) {
        this.$message.error('请上传商品详情图！')
        return;
      }
      if (!this.addForm.specification) {
        this.$message.error('请添加商品规格参数！')
        return;
      }
      let newListData=[];
      this.selectServiceList.forEach(item=>{
        if(item==1){
          newListData.push('无忧退货')
        }else if(item==2){
          newListData.push('保证正品')
        }else if(item==3){
          newListData.push('免费包邮')
        }
      })
      params.goodService=JSON.stringify(newListData);
      console.log(params);
      const { data: res } = await this.$http.post('/shop/editProduct', params)
      if (res.status == 1) {
        this.$message.success('商品修改成功！')
        this.$router.push('/goods/list');
      } else {
        return this.$message.error(res.message);
      }

      // this.$refs.addFormRef.validate(async valid => {
      //   if (!valid) return
      //   // 注意：要添加的商品的名称，不能重复
      //   const { data: res } = await this.$http.post('goods', form)
      //   if (res.meta.status !== 201) return this.$message.error('添加商品失败！')
      //   this.$message.success('添加商品成功！')
      //   // 添加完成，跳转到列表页面
      //   
      // })
      // 1. 要把 addForm.goods_cat 从数组变成 字符串
      // this.addForm.goods_cat = this.addForm.goods_cat.join(',')
      // let form = this.addForm
      // form.goods_cat = form.goods_cat.join(',')
      // const form = _.cloneDeep(this.addForm)
      // form.goods_cat = form.goods_cat.join(',')
      // // console.log(form)

      // // 2. 要把 动态参数 和 静态参数，处理一下，保存到 addForm.attrs 中
      // this.manyParams.forEach(item => {
      //   // console.log(item)
      //   const o = { attr_id: item.attr_id, attr_value: item.attr_vals.join(' ') }
      //   form.attrs.push(o)
      // })

      // this.onlyParams.forEach(item => {
      //   // console.log(item)
      //   const o = { attr_id: item.attr_id, attr_value: item.attr_vals }
      //   form.attrs.push(o)
      // })
      // // 3. 提交表单，完成添加
      // // console.log(form)

      // // 验证表单
      // this.$refs.addFormRef.validate(async valid => {
      //   if (!valid) return
      //   // 注意：要添加的商品的名称，不能重复
      //   const { data: res } = await this.$http.post('goods', form)
      //   if (res.meta.status !== 201) return this.$message.error('添加商品失败！')
      //   this.$message.success('添加商品成功！')
      //   // 添加完成，跳转到列表页面
      //   this.$router.push('/goods/list')
      // })
    }
  },
  // 监视 数据的变化的
  watch: {
    // 监视 被激活的 tab 栏名称的变化
    async activeName(newVal, oldVal) {
      console.log('进入这个状态')
      // 判断用户是否进入到了 动态参数面板
      // if (newVal === '1') {
      //   // 只要进入到了这个 if 分支，
      //   // 则应该立即根据用户选择的 商品分类Id，
      //   // 获取分类下所有的 动态参数；
      //   const { data: res } = await this.$http.get(
      //     `categories/${this.addForm.goods_cat[2]}/attributes`,
      //     {
      //       params: { sel: 'many' }
      //     }
      //   )
      //   if (res.meta.status !== 200) return this.$message.error('获取动态参数失败！')
      //   // 在把动态参数，赋值给 manyParams 之前，先对动态参数的数据，做一下 split 分割
      //   res.data.forEach(item => {
      //     item.attr_vals = item.attr_vals ? item.attr_vals.split(' ') : []
      //   })
      //   // 把获取到的所有动态参数，保存到 data 上供页面使用
      //   this.manyParams = res.data
      //   // console.log(res.data)
      // } else if (newVal === '2') {
      //   // 用户进入了 静态属性面板
      //   const { data: res } = await this.$http.get(
      //     `categories/${this.addForm.goods_cat[2]}/attributes`,
      //     {
      //       params: { sel: 'only' }
      //     }
      //   )
      //   if (res.meta.status !== 200) return this.$message.error('获取静态参数失败！')
      //   this.onlyParams = res.data
      // }
    }
  }
}
